package cn.good.yan.var1;

import java.util.*;
import java.util.function.Consumer;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * 1 var 语法：局部变量的类型推断
 * 2 集合API （stream流 + List.of ）
 * 3 字符串
 * 4 Optional
 *
 * @author shengren.yan
 * @create 2023-05-05
 */
public class VarTest {

    public static void main(String[] args) {
        VarTest varTest = new  VarTest();

        // 1 - var 定义变量
//        varTest.test1();

        // 2 - 集合API
//        varTest.test2();

        // 3 - 字符串
//        varTest.test3();

        // 4 - Optional
        varTest.test4();
    }

    // 1 - var 定义变量
    public void test1(){
        // 定义变量
        var a1 = "abd";
        var a2 = new ArrayList<Integer>();
        var a3 = new StringBuffer("abcdef");
        System.out.println(a1);
        System.out.println(a2);
        System.out.println(a3);

        // 在Lambda表达式 中 使用var 的好处，就是在参数前可以增加注解@Deprecated （可以加其他注解，例子@Nonnull注解）
        Consumer<String> consumer1 = x -> System.out.println(x.toUpperCase());
        Consumer<String> consumer2 = (var x) -> System.out.println(x.toUpperCase());
        Consumer<String> consumer3 = (@Deprecated var x) -> System.out.println(x.toUpperCase());
        consumer1.accept("abc");
        consumer2.accept("abc");
        consumer3.accept("abc");
    }

    // 2 - 集合API
    public void test2(){
        // of 方法使用 ---（只读）
        List<Integer> list2 = List.of(1, 3, 4);
        //  list2.add(5); // 会报错
        Set<Integer> set2 = Set.of(2, 3, 4);
        System.out.println(list2);

        // stream 流 使用 ---
        List<Integer> lsit1 = Arrays.asList(1, 3, 4, 6, 2);
        // takeWhile 从开头开始获取满足的元素，直到不满足为止
        List<Integer> c1 = lsit1.stream().takeWhile(x -> x < 3).collect(Collectors.toList());
        System.out.println(c1); // 结果是 3

        // dropWhile 与takeWhile相反，取出不满足的，直到满足为止
        List<Integer> c2 = lsit1.stream().dropWhile(x -> x < 3).collect(Collectors.toList());
        System.out.println(c2); // 结果是 3

        // ofNullable
        Stream<Object> o1 = Stream.ofNullable(null);
        long count = o1.count(); // 结果是0  不会出现异常
        System.out.println(count);

    }

    // 3 - 字符串
    public void test3(){

        String str = " \t \t\n abc \t ";
        // 判断字符串字符是否都是空
        System.out.println(str.isBlank());

        // 去除字符串首尾空白
        System.out.println(str.strip());
        System.out.println(str.length());
//        去除字符串首尾空白 （中文空格会失效，建议使用strip方法）
//        System.out.println(str.trim());
//        System.out.println(str.length());

        // 去除首部的字符串空格
        System.out.println(str.stripLeading());
        // 去除尾部的字符串空格
        System.out.println(str.stripTrailing());

        System.out.println("----------------------");
        String str2 = " abc ";
        // 复制字符串
        str2 = str2.repeat(3);
        System.out.println(str2); // abc abc abc
        // 行数统计
        long count = str2.lines().count();
        System.out.println(count); // 1行

    }

    // 4 - Optional
    public void test4() {

        // ofNullable 支持存空
        // 如果值为null，取默认值，不会报空指针
        String name = (String) Optional.ofNullable(null).orElse("默认值");
        System.out.println(name);
        // orElseGet 与 orElse的区别，orElseGet可以定义逻辑补充
        String name2 = (String) Optional.ofNullable(null).orElseGet(() -> "默认值 - 可以有一些操作");
        String name3 = (String) Optional.ofNullable(null).orElseGet(() -> {
            return "默认值 - 可以有一些操作" + "xxxx";
        });
        System.out.println(name2);
        System.out.println(name3);

        // 有钱就没异常
        try {
            // 如果值为空，会报错异常 - 指定异常 （没有不会出现异常）
            String name4 = (String)  Optional.ofNullable(null).orElseThrow(() -> new Exception("指定异常"));
            System.out.println(name4);  // 有钱不会抛异常
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }

    }

}
